home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / madtrb13.arc / PFIELD.PAS < prev    next >
Pascal/Delphi Source File  |  1985-05-26  |  6KB  |  162 lines
  1. { A set of routines for protected field forms input
  2.   By Bela Lubkin
  3.   Borland International Technical Support
  4.   1/23/85
  5.   (For PC-DOS Turbo Pascal version 2 or greater)
  6. }
  7.  
  8. Type
  9.   ScreenType=Array [0..1999] Of Record
  10.                                   Ch: Char;
  11.                                   At: Byte;
  12.                                 End;
  13.  
  14. Var
  15.   Screen: ^ScreenType;   { Points to the screen in use, either mono or color }
  16.   ConInPtr1,ConOutPtr1: Integer;  { The addresses of the old console drivers }
  17.   XCursor,YCursor: Byte;              { Current cursor address on the screen }
  18.   ProtectiOn: Boolean;                            { In protected field mode? }
  19.  
  20. Procedure GotoXYTurbo(X,Y: Byte);                      { Call Turbo's GotoXY }
  21.   Begin
  22.     GotoXY(X,Y);
  23.   End;
  24.  
  25. Procedure GotoXY(X,Y: Byte);            { Position the cursor and keep track }
  26.   Begin                                                     { of where it is }
  27.     GotoXYTurbo(X,Y);
  28.     XCursor:=X;
  29.     YCursor:=Y;
  30.   End;
  31.  
  32. Procedure FindForward;    { If protected mode is on, make sure the cursor is }
  33.   Var                  { on a hilighted character by moving it forward until }
  34.     I,J: Integer;        { a non-lowlighted character is found.  If none are }
  35.                         { found anywhere on the screen, the cursor is placed }
  36.   Begin                  { at 1,1, the upper left hand corner of the screen. }
  37.     If ProtectiOn Then      { Note that lowlighted characters are considered }
  38.      Begin                     { to be those with attribute 7: lowlight only }
  39.       I:=80*YCursor+XCursor-81;
  40.       If Screen^[I].At=7 Then    { <--- the choice of attribute for lowlight }
  41.        Begin
  42.         J:=(I+1) Mod 2000;
  43.         While (J<>I) And (Screen^[J].At=7) Do      { <--- lowlight attribute }
  44.          Begin
  45.           J:=J+1;
  46.           If J=2000 Then J:=0;
  47.          End;
  48.         If J=I Then J:=0;      { If we wrapped all the way around the screen }
  49.         GotoXY(J Mod 80+1,J Div 80+1); { without finding a place, choose 1,1 }
  50.        End;                        { Position the cursor at the chosen place }
  51.      End;
  52.   End;
  53.  
  54. Procedure PutCh(C: Byte);  { ConOutPtr points to this.  Print a character on }
  55.   Var                        { the screen.  Skip lowlighted areas if protect }
  56.     I,J: Integer;                                              { mode is on. }
  57.  
  58.   Begin
  59.     If C=8 Then                  { Handle backspace.  Must skip backwards to }
  60.      Begin                                     { previous highlighted field. }
  61.       If ProtectiOn Then
  62.        Begin
  63.         I:=80*YCursor+XCursor-81;
  64.         J:=(I+1999) Mod 2000;
  65.         If Screen^[J].At=7 Then
  66.          Begin
  67.           While (J<>I) And (Screen^[(J+1999) Mod 2000].At=7) Do
  68.             J:=(J+1999) Mod 2000;
  69.           If J=I Then J:=1;
  70.           GotoXY(J Mod 80+1,J Div 80+1);
  71.          End;
  72.        End;
  73.       If XCursor>1 Then XCursor:=XCursor-1;
  74.      End
  75.     Else If C=10 Then      { Handle linefeed.  Mishandled slightly -- should }
  76.      Begin                { do a FindForward but not until after calling the }
  77.       If YCursor<25 Then YCursor:=YCursor+1;                 { old ConOutPtr }
  78.      End
  79.     Else If C=13 Then XCursor:=1       { Handle CR.  Mishandled the same way }
  80.     Else               { Handle normal character.  If protection is on, find }
  81.      Begin              { an unprotected field before writing the character. }
  82.       FindForward;
  83.       If XCursor<80 Then XCursor:=XCursor+1
  84.       Else
  85.        Begin
  86.         XCursor:=1;
  87.         If YCursor<25 Then YCursor:=YCursor+1;
  88.        End;
  89.      End;
  90.     InLine($89/$EC  /  $5D  /  $FF/$26/ConOutPtr1);        { Jump to the old }
  91.     {      MOV SP,BP   POP BP  JMP [ConOutPtr1] }    { console output driver }
  92.   End;
  93.  
  94. Function GetCh: Char;     { ConInPtr points to this.  Its only purpose is to }
  95.   Begin                    { make the blinking cursor appear where the typed }
  96.     FindForward;                          { character will appear, on input. }
  97.     InLine($89/$EC  /  $5D  /  $FF/$26/ConInPtr1);         { Jump to the old }
  98.     {      MOV SP,BP   POP BP  JMP [ConInPtr1] }      { console input driver }
  99.   End;
  100.  
  101. Procedure InitProtect;     { Does the following: figures out which screen is }
  102.   Var                       { being used; turns protection off; sets XCursor }
  103.     M,C: Integer;              { and YCursor to 1; saves pointers to the old }
  104.     T: Byte;                    { console drivers; points the console driver }
  105.                                                { pointers to PutCh and GetCh }
  106.   Begin
  107.     M:=MemW[$B000:0];
  108.     C:=MemW[$B800:0];
  109.     T:=64;
  110.     If (Hi(M)=T) Or (Hi(C)=T) Then T:=65;
  111.     If (Hi(M)=T) Or (Hi(C)=T) Then T:=66;
  112.     GotoXY(1,1);
  113.     Write(Chr(T));
  114.     If Mem[$B000:0]=T Then Screen:=Ptr($B000,0)
  115.     Else Screen:=Ptr($B800,0);
  116.     MemW[$B000:0]:=M;
  117.     MemW[$B800:0]:=C;
  118.     ProtectiOn:=False;
  119.     GotoXY(1,1);
  120.     ConInPtr1:=ConInPtr;
  121.     ConInPtr:=Ofs(GetCh);
  122.     ConOutPtr1:=ConOutPtr;
  123.     ConOutPtr:=Ofs(PutCh);
  124.   End;
  125.  
  126. Procedure ProtectOn;                 { Silly procedure to turn on protection }
  127.   Begin
  128.     ProtectiOn:=True;
  129.   End;
  130.  
  131. Procedure ProtectOff;               { Silly procedure to turn off protection }
  132.   Begin
  133.     ProtectiOn:=False;
  134.   End;
  135.  
  136. { Example program -- remove next line to enable }
  137.  
  138. (*
  139.  
  140. Var
  141.   I: Integer;
  142.   S: String[80];
  143.  
  144. Begin
  145.   InitProtect;          { Initialize the protected field emulator }
  146.   ProtectOn;            { Turn on protection }
  147.   ClrScr;               { Clear the screen -- otherwise it's all protected }
  148.   For I:=0 To 1998 Do
  149.    Begin
  150.     If Random(2)=0 Then LowVideo Else HighVideo;
  151.     Write('*');         { Fill the screen with *'s, about 1/2 protected }
  152.    End;
  153.   HighVideo;            { Important!  Otherwise input will be wierd! }
  154.   GotoXY(1,1);
  155.   For I:=1 To 10 Do
  156.    Begin
  157.     ReadLn(S);          { Demonstrate input and output in protected fields }
  158.     WriteLn(S);
  159.    End;
  160. End.
  161. (**)
  162.